package agent

import (
	"context"
	"fmt"
	"log"
	"os/exec"
	"strings"
	"time"
)

// handleTimeQuery 处理时间查询
func (a *Agent) handleTimeQuery(ctx context.Context, params map[string]interface{}) (string, error) {
	log.Printf("[AGENT-TOOLS] 🕐 处理时间查询请求")
	
	location, ok := params["location"].(string)
	if !ok {
		return "", fmt.Errorf("缺少地点参数")
	}

	log.Printf("[AGENT-TOOLS] 📍 查询地点: %s", location)

	// 时区映射
	timezones := map[string]string{
		"北京": "Asia/Shanghai",
		"上海": "Asia/Shanghai",
		"东京": "Asia/Tokyo",
		"纽约": "America/New_York",
		"伦敦": "Europe/London",
		"巴黎": "Europe/Paris",
		"洛杉矶": "America/Los_Angeles",
		"悉尼": "Australia/Sydney",
		"新加坡": "Asia/Singapore",
		"香港": "Asia/Hong_Kong",
		"台北": "Asia/Taipei",
		"首尔": "Asia/Seoul",
		"莫斯科": "Europe/Moscow",
		"迪拜": "Asia/Dubai",
		"孟买": "Asia/Kolkata",
		"曼谷": "Asia/Bangkok",
		"雅加达": "Asia/Jakarta",
		"马尼拉": "Asia/Manila",
		"吉隆坡": "Asia/Kuala_Lumpur",
		"河内": "Asia/Ho_Chi_Minh",
	}

	timezone, exists := timezones[location]
	if !exists {
		return "", fmt.Errorf("不支持的地点: %s", location)
	}

	// 获取指定时区的时间
	loc, err := time.LoadLocation(timezone)
	if err != nil {
		log.Printf("[AGENT-TOOLS] ❌ 加载时区失败: %v", err)
		return "", fmt.Errorf("加载时区失败: %v", err)
	}

	currentTime := time.Now().In(loc)
	result := fmt.Sprintf("%s当前时间是：%s", location, currentTime.Format("2006年01月02日 15:04:05 (Monday)"))
	
	log.Printf("[AGENT-TOOLS] ✅ 时间查询成功: %s", result)
	return result, nil
}

// handleCalculation 处理数学计算
func (a *Agent) handleCalculation(ctx context.Context, params map[string]interface{}) (string, error) {
	log.Printf("[AGENT-TOOLS] 🧮 处理计算请求")
	
	expression, ok := params["expression"].(string)
	if !ok {
		return "", fmt.Errorf("缺少表达式参数")
	}

	log.Printf("[AGENT-TOOLS] 📝 计算表达式: %s", expression)

	// 清理和验证表达式
	cleanExpression := a.cleanExpression(expression)
	if cleanExpression == "" {
		return "", fmt.Errorf("无效的数学表达式")
	}

	// 使用内置计算器
	result, err := a.evaluateExpression(cleanExpression)
	if err != nil {
		log.Printf("[AGENT-TOOLS] ❌ 计算失败: %v", err)
		return "", fmt.Errorf("计算失败: %v", err)
	}

	finalResult := fmt.Sprintf("%s", result)
	log.Printf("[AGENT-TOOLS] ✅ 计算成功: %s = %s", expression, finalResult)
	return finalResult, nil
}

// handleMemorySearch 处理记忆搜索
func (a *Agent) handleMemorySearch(ctx context.Context, params map[string]interface{}) (string, error) {
	log.Printf("[AGENT-TOOLS] 🧠 处理记忆搜索请求")
	
	query, ok := params["query"].(string)
	if !ok {
		return "", fmt.Errorf("缺少搜索关键词")
	}

	// 从参数中获取会话ID，如果没有则使用默认值
	sessionID := "default"
	if sid, exists := params["session_id"]; exists {
		if sidStr, ok := sid.(string); ok {
			sessionID = sidStr
		}
	}

	log.Printf("[AGENT-TOOLS] 🔍 搜索关键词: %s, 会话ID: %s", query, sessionID)

	// 搜索记忆
	memories := a.memory.SearchMemory(query, sessionID, 5)
	
	if len(memories) == 0 {
		result := fmt.Sprintf("没有找到与 \"%s\" 相关的历史记录", query)
		log.Printf("[AGENT-TOOLS] ℹ️ %s", result)
		return result, nil
	}

	// 格式化搜索结果
	var resultBuilder strings.Builder
	resultBuilder.WriteString(fmt.Sprintf("找到 %d 条与 \"%s\" 相关的记录：\n\n", len(memories), query))

	for i, memory := range memories {
		timeStr := memory.Timestamp.Format("01-02 15:04")
		resultBuilder.WriteString(fmt.Sprintf("%d. [%s] %s\n", i+1, timeStr, memory.Content))
	}

	result := resultBuilder.String()
	log.Printf("[AGENT-TOOLS] ✅ 记忆搜索成功，找到 %d 条记录", len(memories))
	return result, nil
}

// cleanExpression 清理数学表达式
func (a *Agent) cleanExpression(expression string) string {
	// 移除空格
	expression = strings.ReplaceAll(expression, " ", "")
	
	// 替换中文运算符
	expression = strings.ReplaceAll(expression, "加", "+")
	expression = strings.ReplaceAll(expression, "减", "-")
	expression = strings.ReplaceAll(expression, "乘", "*")
	expression = strings.ReplaceAll(expression, "除", "/")
	expression = strings.ReplaceAll(expression, "×", "*")
	expression = strings.ReplaceAll(expression, "÷", "/")
	
	// 移除常见的描述词
	expression = strings.ReplaceAll(expression, "等于", "")
	expression = strings.ReplaceAll(expression, "是", "")
	expression = strings.ReplaceAll(expression, "多少", "")
	expression = strings.ReplaceAll(expression, "？", "")
	expression = strings.ReplaceAll(expression, "?", "")
	
	return strings.TrimSpace(expression)
}

// evaluateExpression 计算数学表达式
func (a *Agent) evaluateExpression(expression string) (string, error) {
	// 处理特殊函数
	if strings.Contains(expression, "sqrt") {
		return a.evaluateSqrt(expression)
	}
	
	if strings.Contains(expression, "pow") {
		return a.evaluatePow(expression)
	}
	
	// 处理基本四则运算
	return a.evaluateBasicMath(expression)
}

// evaluateSqrt 计算平方根
func (a *Agent) evaluateSqrt(expression string) (string, error) {
	// 简单的平方根计算实现
	// 这里可以使用更复杂的数学库，但为了简单起见使用基本实现
	
	// 使用Python进行计算（如果可用）
	if result, err := a.evaluateWithPython(fmt.Sprintf("import math; print(math.%s)", expression)); err == nil {
		return strings.TrimSpace(result), nil
	}
	
	return "", fmt.Errorf("平方根计算暂不支持")
}

// evaluatePow 计算幂运算
func (a *Agent) evaluatePow(expression string) (string, error) {
	// 使用Python进行计算（如果可用）
	if result, err := a.evaluateWithPython(fmt.Sprintf("import math; print(math.%s)", expression)); err == nil {
		return strings.TrimSpace(result), nil
	}
	
	return "", fmt.Errorf("幂运算计算暂不支持")
}

// evaluateBasicMath 计算基本数学运算
func (a *Agent) evaluateBasicMath(expression string) (string, error) {
	// 使用Python进行安全的数学计算
	if result, err := a.evaluateWithPython(fmt.Sprintf("print(%s)", expression)); err == nil {
		return strings.TrimSpace(result), nil
	}
	
	// 如果Python不可用，使用简单的计算逻辑
	return a.simpleCalculate(expression)
}

// evaluateWithPython 使用Python计算
func (a *Agent) evaluateWithPython(pythonCode string) (string, error) {
	cmd := exec.Command("python3", "-c", pythonCode)
	output, err := cmd.Output()
	if err != nil {
		return "", err
	}
	return string(output), nil
}

// simpleCalculate 简单计算实现
func (a *Agent) simpleCalculate(expression string) (string, error) {
	// 这里实现一个简单的计算器
	// 为了简单起见，只处理最基本的运算
	
	// 检查是否包含不安全的字符
	allowedChars := "0123456789+-*/.() "
	for _, char := range expression {
		if !strings.ContainsRune(allowedChars, char) {
			return "", fmt.Errorf("表达式包含不支持的字符: %c", char)
		}
	}
	
	// 使用Go的基本运算（这里简化实现）
	// 实际项目中应该使用专门的数学表达式解析库
	
	// 简单的加法示例
	if strings.Contains(expression, "+") && !strings.Contains(expression, "-") && !strings.Contains(expression, "*") && !strings.Contains(expression, "/") {
		parts := strings.Split(expression, "+")
		if len(parts) == 2 {
			var sum float64
			for _, part := range parts {
				part = strings.TrimSpace(part)
				if val, err := parseFloat(part); err == nil {
					sum += val
				} else {
					return "", fmt.Errorf("无法解析数字: %s", part)
				}
			}
			return fmt.Sprintf("%.2f", sum), nil
		}
	}
	
	return "", fmt.Errorf("暂不支持复杂的数学表达式，请使用简单的运算")
}

// parseFloat 解析浮点数
func parseFloat(s string) (float64, error) {
	// 简单的浮点数解析
	var result float64
	var decimal float64 = 1
	var isDecimal bool
	var isNegative bool
	
	s = strings.TrimSpace(s)
	if s == "" {
		return 0, fmt.Errorf("空字符串")
	}
	
	if s[0] == '-' {
		isNegative = true
		s = s[1:]
	} else if s[0] == '+' {
		s = s[1:]
	}
	
	for _, char := range s {
		if char == '.' {
			if isDecimal {
				return 0, fmt.Errorf("多个小数点")
			}
			isDecimal = true
			continue
		}
		
		if char < '0' || char > '9' {
			return 0, fmt.Errorf("无效字符: %c", char)
		}
		
		digit := float64(char - '0')
		if isDecimal {
			decimal *= 10
			result += digit / decimal
		} else {
			result = result*10 + digit
		}
	}
	
	if isNegative {
		result = -result
	}
	
	return result, nil
}
